from PublicReference.base import *

class 黑暗武士主动技能(主动技能):
    类型 = '物理'
    武器惩罚类型 = '物理百分比'
    计算CD = 0
    def 等效CD(self, 武器类型 , 输出类型,恢复速度=1):
        if self.计算CD != 0:
            return round(self.计算CD, 1)
        return round(self.CD  / (1 if 恢复速度 == 0 else self.恢复) * 武器冷却惩罚(武器类型,self.武器惩罚类型,self.版本), 1)
class 黑暗武士技能0(黑暗武士主动技能):
    名称 = '挑击'
    类型 = '物理'
    所在等级 = 1
    等级上限 = 20
    基础等级 = 10
    基础 = 88.9
    成长 = 11.1
    CD = 2.0
    TP成长 = 0.08
    TP上限 = 5

class 黑暗武士技能1(黑暗武士主动技能):
    名称 = '暗影斩'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 1
    等级上限 = 60
    基础等级 = 50
    基础 = 577.673
    成长 = 65.327
    CD = 3.1
    TP成长 = 0.1
    TP上限 = 5

class 黑暗武士技能2(黑暗武士主动技能):
    名称 = '黑暗十字斩'
    类型 = '物理'
    所在等级 = 5
    等级上限 = 60
    基础等级 = 50
    基础 = 125.776
    成长 = 14.224
    攻击次数 = 2
    基础2 = 552.490
    成长2 = 52.531
    攻击次数2 = 1
    CD = 3.0
    TP成长 = 0.08
    TP上限 = 5

class 黑暗武士技能3(黑暗武士主动技能):
    名称 = '暗影·波动剑'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 5
    等级上限 = 60
    基础等级 = 50
    基础 = 628.98
    成长 = 71.020
    CD = 3.1
    TP成长 = 0.08
    TP上限 = 5

class 黑暗武士技能4(黑暗武士主动技能):
    名称 = '漩涡斩'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 5
    等级上限 = 60
    基础等级 = 50
    基础 = 622
    成长 = 71
    基础2 = 422
    成长2 = 47.5
    攻击次数2 = 3
    CD = 8
    TP成长 = 0
    TP上限 = 3

    def 等效百分比(self, 武器类型):
        if self.等级 == 0:
            return 0
        else:
            return int((self.攻击次数 * (self.基础 + self.成长 * self.等级) + (self.攻击次数2+self.TP等级) * (self.基础2 + self.成长2 * self.等级))* self.倍率)


class 黑暗武士技能5(黑暗武士主动技能):
    名称 = '滑斩'
    类型 = '物理'
    所在等级 = 1
    等级上限 = 60
    基础等级 = 50
    基础 = 749.347
    成长 = 84.653
    CD = 3.0

class 黑暗武士技能6(黑暗武士主动技能):
    名称 = '跃斩'
    类型 = '物理'
    所在等级 = 1
    等级上限 = 60
    基础等级 = 50
    基础 = 749.347
    成长 = 84.653
    CD = 3.0
    # 钝器冲击波
    def 等效百分比(self, 武器类型):
        if self.等级 == 0:
            return 0
        else:
            if 武器类型 != '钝器':
                return self.基础 + self.成长 * self.等级
            else:
                return (self.基础 + self.成长 * self.等级) + (442.269 + 52.531 * self.等级)

class 黑暗武士技能7(黑暗武士主动技能):
    名称 = '跃地斩'
    类型 = '物理'
    所在等级 = 10
    等级上限 = 60
    基础等级 = 48
    基础 = 320.429
    成长 = 34.571
    攻击次数 = 4
    CD = 4.0
    TP成长 = 0.08
    TP上限 = 5

class 黑暗武士技能8(黑暗武士主动技能):
    名称 = '冥光斩'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 10
    等级上限 = 60
    基础等级 = 48
    基础 = 435.787
    成长 = 49.213
    攻击次数 = 2
    CD = 10.5
    TP成长 = 0.10
    TP上限 = 5

class 黑暗武士技能9(黑暗武士主动技能):
    名称 = '瞬影斩'
    类型 = '物理'
    所在等级 = 25
    等级上限 = 60
    基础等级 = 41
    基础 = 1299.2
    成长 = 146.8
    攻击次数 = 2
    TP成长 =0.1
    TP上限 = 5
    CD = 5

class 黑暗武士技能10(黑暗武士主动技能):
    名称 = '暗月斩'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 5
    等级上限 = 60
    基础等级 = 50
    基础 = 395.347
    成长 = 44.653
    基础2 = 427.633
    成长2 = 48.367
    攻击次数2 = 1
    CD = 4.2
    TP成长 = 0.08
    TP上限 = 5

class 黑暗武士技能11(黑暗武士主动技能):
    名称 = '暗影三击剑'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 10
    等级上限 = 60
    基础等级 = 32
    基础 = 1822.806
    成长 = 346.194
    CD = 8.4

class 黑暗武士技能12(黑暗武士主动技能):
    名称 = '暗劲爆发'
    类型 = '物理'
    所在等级 = 15
    等级上限 = 60
    基础等级 = 46
    基础 = 353.044
    成长 = 39.956
    基础2 = 389.933
    成长2 = 44.067
    攻击次数2 = 8
    CD = 15.0
    TP成长 = 0.1
    TP上限 = 5


class 黑暗武士技能13(黑暗武士主动技能):
    名称 = '邪影·波动剑'
    类型 = '魔法'
    武器惩罚类型 = '魔法固伤'
    所在等级 = 20
    等级上限 = 60
    基础等级 = 43
    基础 = 100.0
    成长 = 0
    基础2 = 709.810
    成长2 = 80.190
    攻击次数2 = 3
    基础3 = 141.905
    成长3 = 16.095
    攻击次数3 = 4
    CD = 7.0

class 黑暗武士技能14(黑暗武士主动技能):
    名称 = '暗魂之手'
    类型 = '物理'
    武器惩罚类型 = '物理百分比'
    所在等级 = 20
    等级上限 = 60
    基础等级 = 43
    基础 = 1975-201
    成长 = 201
    基础2 = 1341-136
    成长2 = 136
    攻击次数2 = 1
    CD = 6.0
    TP成长 = 0.1
    TP上限 = 5

class 黑暗武士技能15(黑暗武士主动技能):
    名称 = '突刺'
    类型 = '物理'
    所在等级 = 10
    等级上限 = 60
    基础等级 = 48
    基础 = 160.745 * 3
    成长 = 18.255 * 3
    攻击次数 = 3
    CD = 3
    TP上限 = 3
    TP成长 = -0.1

    # 太/光加成
    def 等效百分比(self, 武器类型):
        if self.等级 == 0:
            return 0
        else:
            if 武器类型 == '光剑' or '太刀':
                self.基础 = 112.213
                self.成长 = 12.787
                self.攻击次数 = 5
            # Tp每增加1级，攻击减少10%，多段攻击增加2次
            return int((self.攻击次数 + 2*self.TP等级) * (self.基础 + self.成长 * self.等级)*(1 + self.TP成长 * self.TP等级) * self.倍率)
                # return (112.213 + 12.787 * self.等级) * 5
            # else:
            #     return self.基础 + self.成长 * self.等级

class 黑暗武士技能16(黑暗武士主动技能):
    名称 = '暗影鞭'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 20
    等级上限 = 60
    基础等级 = 29
    基础 = 635.357
    成长 = 120.643
    基础2 = 1483.5
    成长2 = 281.5
    攻击次数2 = 1
    CD = 8.4
    TP成长 = 0.10
    TP上限 = 5

class 黑暗武士技能17(黑暗武士主动技能):
    名称 = '灭魂封魔斩'
    类型 = '物理'
    所在等级 = 25
    等级上限 = 60
    基础等级 = 41
    基础 = 3785.525 * 1.24
    成长 = 427.275 * 1.24
    CD = 30
    TP成长 = 0.10
    TP上限 = 5

class 黑暗武士技能18(黑暗武士主动技能):
    名称 = '冥魂珠'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 30
    等级上限 = 60
    基础等级 = 38
    基础 = 293.811
    成长 = 33.189
    攻击次数 = 13
    基础2 = 668.514
    成长2 = 75.486
    攻击次数2 = 1
    CD = 10.5
    # Tp每级增加攻击次数3
    TP成长 = 0.1
    TP上限 = 3

    def 等效百分比(self, 武器类型):
        if self.等级 == 0:
            return 0
        else:
            return int(((self.攻击次数 + 3*self.TP等级) * (self.基础 + self.成长 * self.等级) + self.攻击次数2 * (self.基础2 + self.成长2 * self.等级)) * self.倍率)


class 黑暗武士技能19(黑暗武士主动技能):
    名称 = '暗影升龙击'
    类型 = '物理'
    所在等级 = 30
    等级上限 = 60
    基础等级 = 38
    基础 = 3480.027
    成长 = 392.973
    CD = 10

class 黑暗武士技能20(黑暗武士主动技能):
    名称 = '冥魂之陨'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 35
    等级上限 = 60
    基础等级 =36
    数据1 = [0, 288, 318, 347, 376, 406, 435, 464, 494, 523, 552, 581, 611, 640, 669, 699, 728, 757, 787, 816, 845, 875, 904, 933, 962, 992, 1021, 1050, 1080, 1109, 1138, 1168, 1197, 1226, 1255, 1285, 1314, 1343, 1373, 1402, 1431, 1461, 1490, 1519, 1549, 1578, 1607, 1636, 1666, 1695, 1724, 1754, 1783, 1812, 1842, 1871, 1900, 1930, 1959, 1988, 2017, 2047, 2076, 2105, 2135, 2164, 2193, 2223, 2252, 2281, 2311]
    #基础 = 258.686
    #成长 = 29.314
    攻击次数1 = 24
    CD = 21
    TP成长 = 0.1
    TP上限 = 5
    是否有护石 = 1
    护石选项 = ['魔界', '圣痕']
    def 装备护石(self, x):
        if x == 0:
            self.攻击次数1 = 24 * 1.14
            self.CD *= 0.9
        elif x == 1:
            self.攻击次数1 = 24 * 1.23
            self.CD *= 0.9

    def 等效百分比(self, 武器类型):
        return (self.数据1[self.等级] * self.攻击次数1) * (1 + self.TP成长 * self.TP等级) * self.倍率

    

class 黑暗武士技能21(黑暗武士主动技能):
    名称 = '破魂之刃'
    类型 = '物理'
    所在等级 = 35
    等级上限 = 60
    基础等级 = 36
    数据1 = [0, 1184, 1304, 1424, 1544, 1665, 1785, 1905, 2025, 2145, 2265, 2386, 2506, 2626, 2746, 2866, 2986, 3107, 3227, 3347, 3467, 3587, 3707, 3828, 3948, 4068, 4188, 4308, 4428, 4549, 4669, 4789, 4909, 5029, 5149, 5270, 5390, 5510, 5630, 5750, 5870, 5991, 6111, 6231, 6351, 6471, 6591, 6712, 6832, 6952, 7072, 7192, 7312, 7433, 7553, 7673, 7793, 7913, 8033, 8153, 8274, 8394, 8514, 8634, 8754, 8874, 8995, 9115, 9235]
    数据2 = [0, 5986, 6594, 7201, 7809, 8416, 9023, 9631, 10238, 10845, 11453, 12060, 12668, 13275, 13882, 14490, 15097, 15704, 16312, 16919, 17527, 18134, 18741, 19349, 19956, 20563, 21171, 21778, 22386, 22993, 23600, 24208, 24815, 25422, 26030, 26637, 27245, 27852, 28459, 29067, 29674, 30281, 30889, 31496, 32104, 32711, 33318, 33926, 34533, 35140, 35748, 36355, 36963, 37570, 38177, 38785, 39392, 39999, 40607, 41214, 41822, 42429, 43036, 43644, 44251, 44858, 45466, 46073, 46681]
    CD = 20
    TP成长 = 0.1
    TP上限 = 5

    def 等效百分比(self, 武器类型):
        return (self.数据1[self.等级] + self.数据2[self.等级]) * (1 + self.TP成长 * self.TP等级) * self.倍率

class 黑暗武士技能22(黑暗武士主动技能):
    名称 = '凝魂波动阵'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 35
    等级上限 = 60
    基础等级 = 36
    基础 = 1875.171
    成长 = 211.829
    基础2 = 622.629
    成长2 = 70.371
    攻击次数2 = 7
    CD = 21
    TP成长 = 0.1
    TP上限 = 5



class 黑暗武士技能23(黑暗武士主动技能):
    名称 = '破魂斩'
    类型 = '物理'
    所在等级 = 40
    等级上限 = 60
    基础等级 = 33
    数据1 = [0, 5645, 6218, 6791, 7364, 7937, 8509, 9082, 9655, 10228, 10800, 11373, 11946, 12519, 13092, 13664, 14237, 14810, 15383, 15955, 16528, 17101, 17674, 18247, 18819, 19392, 19965, 20538, 21110, 21683, 22256, 22829, 23402, 23974, 24547, 25120, 25693, 26265, 26838, 27411, 27984, 28557, 29129, 29702, 30275, 30848, 31420, 31993, 32566, 33139, 33712, 34284, 34857, 35430, 36003, 36575, 37148, 37721, 38294, 38867, 39439, 40012, 40585, 41158, 41731, 42303, 42876, 43449, 44022, 44594, 45167]
    CD = 15
    TP成长 = 0.12
    TP上限 = 5

    def 等效百分比(self, 武器类型):
        return self.数据1[self.等级] * (1 + self.TP成长 * self.TP等级) * self.倍率

class 黑暗武士技能24(黑暗武士主动技能):
    名称 = '冥炎破空斩'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 40
    等级上限 = 60
    基础等级 = 33
    数据1 = [0, 1294, 1425, 1557, 1688, 1819, 1950, 2082, 2213, 2344, 2476, 2607, 2738, 2870, 3001, 3132, 3264, 3395, 3526, 3658, 3789, 3920, 4052, 4183, 4314, 4445, 4577, 4708, 4839, 4971, 5102, 5233, 5365, 5496, 5627, 5759, 5890, 6021, 6153, 6284, 6415, 6547, 6678, 6809, 6940, 7072, 7203, 7334, 7466, 7597, 7728, 7860, 7991, 8122, 8254, 8385, 8516, 8648, 8779, 8910, 9041, 9173, 9304, 9435, 9567, 9698, 9829, 9961, 10092, 10223, 10355]
    数据2 = [0, 1945, 2142, 2340, 2537, 2734, 2932, 3129, 3326, 3524, 3721, 3919, 4116, 4313, 4511, 4708, 4905, 5103, 5300, 5497, 5695, 5892, 6090, 6287, 6484, 6682, 6879, 7076, 7274, 7471, 7668, 7866, 8063, 8260, 8458, 8655, 8853, 9050, 9247, 9445, 9642, 9839, 10037, 10234, 10431, 10629, 10826, 11024, 11221, 11418, 11616, 11813, 12010, 12208, 12405, 12602, 12800, 12997, 13195, 13392, 13589, 13787, 13984, 14181, 14379, 14576, 14773, 14971, 15168, 15366, 15563]
    数据3 = [0, 3890, 4285, 4680, 5075, 5469, 5864, 6259, 6653, 7048, 7443, 7838, 8232, 8627, 9022, 9416, 9811, 10206, 10601, 10995, 11390, 11785, 12180, 12574, 12969, 13364, 13758, 14153, 14548, 14943, 15337, 15732, 16127, 16521, 16916, 17311, 17706, 18100, 18495, 18890, 19285, 19679, 20074, 20469, 20863, 21258, 21653, 22048, 22442, 22837, 23232, 23626, 24021, 24416, 24811, 25205, 25600, 25995, 26390, 26784, 27179, 27574, 27968, 28363, 28758, 29153, 29547, 29942, 30337, 30732, 31126]
    数据4 = [0, 130, 143, 156, 169, 183, 196, 209, 222, 235, 249, 262, 275, 288, 301, 315, 328, 341, 354, 367, 381, 394, 407, 420, 434, 447, 460, 473, 486, 500, 513, 526, 539, 552, 566, 579, 592, 605, 618, 632, 645, 658, 671, 684, 698, 711, 724, 737, 751, 764, 777, 790, 803, 817, 830, 843, 856, 869, 883, 896, 909, 922, 935, 949, 962, 975, 988, 1002, 1015, 1028, 1041]
    攻击次数1 = 2
    攻击次数2 = 2
    攻击次数3 = 2
    攻击次数4 = 8
    CD = 47.2
    TP成长 = 0.1
    TP上限 = 5
    是否有护石 = 1
    护石选项 = ['魔界', '圣痕']
    def 装备护石(self, x):
        if x == 0:
            self.攻击次数3 = 2 * 1.34
            self.攻击次数4 = 8 * 2.67
        elif x == 1:
            self.攻击次数3 = 2 * 1.34
            self.攻击次数4 = 8 * 3.99

    def 等效百分比(self, 武器类型):
        return (self.数据1[self.等级] * self.攻击次数1 + self.数据2[self.等级] * self.攻击次数2 + self.数据3[self.等级] * self.攻击次数3 + self.数据4[self.等级] * self.攻击次数4) * (1 + self.TP成长 * self.TP等级) * self.倍率

class 黑暗武士技能25(黑暗武士主动技能):
    名称 = '禁魂斩'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 40
    等级上限 = 60
    基础等级 = 33
    数据1 = [0, 7246, 7982, 8717, 9452, 10187, 10922, 11658, 12393, 13128, 13863, 14598, 15334, 16069, 16804, 17539, 18274, 19010, 19745, 20480, 21215, 21950, 22686, 23421, 24156, 24891, 25626, 26362, 27097, 27832, 28567, 29302, 30038, 30773, 31508, 32243, 32978, 33714, 34449, 35184, 35919, 36654, 37390, 38125, 38860, 39595, 40330, 41066, 41801, 42536, 43271, 44006, 44742, 45477, 46212, 46947, 47682, 48418, 49153, 49888, 50623, 51358, 52094, 52829, 53564, 54299, 55034, 55770, 56505, 57240, 57975]
    CD = 21
    TP成长 = 0
    TP上限 = 5

    def 等效百分比(self, 武器类型):
        return self.数据1[self.等级] * (1 + self.TP成长 * self.TP等级) * self.倍率

    
class 黑暗武士技能26(黑暗武士主动技能):
    名称 = '魔狱裂魂斩'
    所在等级 = 45
    等级上限 = 60
    基础等级 = 31
    数据1=[0, 377, 415, 453, 492, 530, 568, 607, 645, 683, 721, 760, 798, 836, 875, 913, 951, 989, 1028, 1066, 1104, 1142, 1181, 1219, 1257, 1296, 1334, 1372, 1410, 1449, 1487, 1525, 1564, 1602, 1640, 1678, 1717, 1755, 1793, 1832, 1870, 1908, 1946, 1985, 2023, 2061, 2100, 2138, 2176, 2214, 2253, 2291, 2329, 2367, 2406, 2444, 2482, 2521, 2559, 2597, 2635, 2674, 2712, 2750, 2789, 2827, 2865, 2903, 2942, 2980, 3018]
    数据2=[0, 2640, 2908, 3176, 3444, 3712, 3980, 4248, 4516, 4784, 5052, 5319, 5587, 5855, 6123, 6391, 6659, 6927, 7195, 7463, 7731, 7999, 8267, 8534, 8802, 9070, 9338, 9606, 9874, 10142, 10410, 10678, 10946, 11214, 11481, 11749, 12017, 12285, 12553, 12821, 13089, 13357, 13625, 13893, 14161, 14428, 14696, 14964, 15232, 15500, 15768, 16036, 16304, 16572, 16840, 17108, 17376, 17643, 17911, 18179, 18447, 18715, 18983, 19251, 19519, 19787, 20055, 20323, 20590, 20858, 21126]
    数据3=[0, 1850, 2037, 2225, 2413, 2601, 2788, 2976, 3164, 3351, 3539, 3727, 3915, 4102, 4290, 4478, 4665, 4853, 5041, 5228, 5416, 5604, 5792, 5979, 6167, 6355, 6542, 6730, 6918, 7105, 7293, 7481, 7669, 7856, 8044, 8232, 8419, 8607, 8795, 8983, 9170, 9358, 9546, 9733, 9921, 10109, 10296, 10484, 10672, 10860, 11047, 11235, 11423, 11610, 11798, 11986, 12174, 12361, 12549, 12737, 12924, 13112, 13300, 13487, 13675, 13863, 14051, 14238, 14426, 14614, 14801]
    攻击次数1 = 1
    攻击次数2 = 1
    攻击次数3 = 6
    CD = 40
    TP成长 = 0.10
    TP上限 = 5

    def 等效百分比(self, 武器类型):
        return (self.数据1[self.等级] * self.攻击次数1 + self.数据2[self.等级] * self.攻击次数2 + self.数据3[self.等级] * self.攻击次数3) * (1 + self.TP成长 * self.TP等级) * self.倍率


class 黑暗武士技能27(黑暗武士主动技能):
    名称 = '黑暗明王阵'
    类型 = '魔法'
    武器惩罚类型 = '魔法百分比'
    所在等级 = 45
    等级上限 = 60
    基础等级 = 31
    数据1 = [0, 1960, 2159, 2358, 2557, 2750, 2956, 3150, 3348, 3547, 3749, 3948, 4145, 4346, 4542, 4742, 4940, 5141, 5336, 5538, 5735, 5934, 6136, 6334, 6533, 6727, 6931, 7126, 7325, 7524, 7723, 7922, 8122, 8321, 8516, 8720, 8915, 9114, 9311, 9514, 9713, 9908, 10111, 10306, 10505, 10704, 10904, 11100, 11303, 11498, 11698, 11898, 12096, 12295, 12496, 12690, 12890, 13090, 13290, 13489, 13687, 13888, 14081, 14281, 14480, 14680, 14879, 15077, 15277, 15475, 15673]
    数据2 = [0, 4547, 5010, 5467, 5926, 6409, 6847, 7326, 7790, 8248, 8700, 9160, 9629, 10080, 10553, 11009, 11473, 11929, 12402, 12854, 13322, 13783, 14233, 14695, 15156, 15635, 16076, 16555, 17016, 17477, 17935, 18395, 18856, 19316, 19789, 20231, 20706, 21167, 21638, 22082, 22543, 23017, 23464, 23942, 24398, 24862, 25315, 25788, 26237, 26708, 27169, 27625, 28088, 28546, 29006, 29482, 29938, 30398, 30852, 31315, 31776, 32233, 32714, 33170, 33631, 34090, 34552, 35012, 35468, 35933, 36398]
    攻击次数1 = 4
    攻击次数2 = 1
    CD = 47.2
    TP成长 = 0.10
    TP上限 = 5

    def 等效百分比(self, 武器类型):
        return (self.数据1[self.等级] * self.攻击次数1 + self.数据2[self.等级] * self.攻击次数2) * (1 + self.TP成长 * self.TP等级) * self.倍率

class 黑暗武士技能28(黑暗武士主动技能):
    名称 = '魔影剑舞'
    所在等级 = 45
    等级上限 = 60
    基础等级 = 31
    数据1 = [0, 720, 794, 864, 938, 1011, 1085, 1157, 1230, 1304, 1377, 1448, 1521, 1595, 1667, 1740, 1814, 1887, 1961, 2033, 2106, 2178, 2252, 2325, 2397, 2471, 2544, 2616, 2690, 2762, 2835, 2909, 2981, 3054, 3126, 3201, 3273, 3345, 3419, 3494, 3564, 3638, 3711, 3783, 3857, 3930, 4004, 4076, 4149, 4223, 4293, 4365, 4439, 4511, 4583, 4656, 4730, 4802, 4875, 4949, 5021, 5094, 5166, 5238, 5312, 5385, 5457, 5531, 5603, 5675, 5748]
    数据2 = [0, 1725, 1898, 2079, 2252, 2429, 2600, 2777, 2955, 3128, 3297, 3480, 3653, 3828, 4007, 4179, 4352, 4524, 4703, 4878, 5051, 5234, 5403, 5576, 5754, 5931, 6102, 6279, 6453, 6633, 6806, 6978, 7157, 7329, 7508, 7677, 7854, 8033, 8205, 8376, 8559, 8732, 8907, 9084, 9257, 9432, 9605, 9783, 9956, 10128, 10311, 10494, 10667, 10845, 11022, 11195, 11373, 11550, 11723, 11898, 12077, 12249, 12426, 12603, 12777, 12954, 13131, 13304, 13482, 13659, 13832]
    攻击次数1 = 13
    护石斩击攻击力 = 1
    护石锤击 = 0
    护石冲击波 = 0
    护石黑暗气息 = 0
    护石升龙斩 = 0
    攻击次数2 = 3
    CD = 45
    TP成长 = 0.10
    TP上限 = 5
    倍率 = 1
    是否有护石 = 1
    护石选项 = ['魔界', '圣痕']
    def 装备护石(self, x):
        if x == 0:
            self.护石斩击攻击力 = 0.5
            self.攻击次数2 = 0
            # 锤击1次
            self.护石锤击 = 0.19
            # 冲击波1次
            self.护石冲击波 = 1.3
            # 黑暗气息6次
            self.护石黑暗气息 = 0.91 * 6
            self.护石升龙斩 = 0.96
        elif x == 1:
            self.护石斩击攻击力 = 0.5
            self.攻击次数2 = 0
            self.护石锤击 = 0.19
            self.护石冲击波 = 1.3
            self.护石黑暗气息 = 0.91 * 6
            self.护石升龙斩 = 1.63

    def 等效百分比(self, 武器类型):
        return (self.数据1[self.等级] * self.攻击次数1 * self.护石斩击攻击力 + 
        self.数据2[self.等级] * self.攻击次数2 + 
        self.数据2[self.等级] * self.护石锤击 + 
        self.数据2[self.等级] * self.护石冲击波 + 
        self.数据2[self.等级] * self.护石黑暗气息 + 
        self.数据2[self.等级] * self.护石升龙斩 ) * (1 + self.TP成长 * self.TP等级) * self.倍率


class 黑暗武士技能29(黑暗武士主动技能):
    名称 = '幽魂剑'
    所在等级 = 50
    等级上限 = 40
    基础等级 = 19
    数据1 = [0, 206, 239, 272, 305, 338, 371, 404, 437, 469, 502, 535, 568, 601, 634, 667, 700, 733, 766, 799, 832, 865, 897, 930, 963, 996, 1029, 1062, 1095, 1128, 1161, 1194, 1227, 1260, 1293, 1326, 1358, 1391, 1424, 1457, 1490, 1523, 1556, 1589, 1622, 1655, 1688, 1721, 1754, 1786, 1819, 1852, 1885, 1918, 1951, 1984, 2017, 2050, 2083, 2116, 2149, 2182, 2215, 2247, 2280, 2313, 2346, 2379, 2412, 2445, 2478]
    数据2 = [0, 6815, 7902, 8988, 10075, 11161, 12248, 13335, 14421, 15508, 16594, 17681, 18767, 19854, 20941, 22027, 23114, 24200, 25287, 26373, 27460, 28547, 29633, 30720, 31806, 32893, 33979, 35066, 36153, 37239, 38326, 39412, 40499, 41585, 42672, 43758, 44845, 45932, 47018, 48105, 49191, 50278, 51364, 52451, 53538, 54624, 55711, 56797, 57884, 58970, 60057, 61144, 62230, 63317, 64403, 65490, 66576, 67663, 68750, 69836, 70923, 72009, 73096, 74182, 75269, 76355, 77442, 78529, 79615, 80702, 81788]
    攻击次数1 = 33
    攻击次数2 = 1
    CD = 45
    是否有护石 = 1
    护石选项 = ['圣痕']
    def 装备护石(self, x):
        if x == 0:
            self.攻击次数1 = 6
            self.攻击次数2 = 2.27
            self.CD *= 0.89

    def 等效百分比(self, 武器类型):
        return (self.数据1[self.等级] * self.攻击次数1 + self.数据2[self.等级] * self.攻击次数2) * self.倍率


class 黑暗武士技能30(黑暗武士主动技能):
    名称 = '暗炎冥魂波'
    所在等级 = 60
    等级上限 = 40
    基础等级 = 16
    数据1 = [0, 3209, 3721, 4232, 4744, 5256, 5767, 6279, 6791, 7302, 7814, 8326, 8837, 9349, 9861, 10372, 10884, 11396, 11907, 12419, 12931, 13442, 13954, 14466, 14977, 15489, 16001, 16512, 17024, 17535, 18047, 18559, 19070, 19582, 20094, 20605, 21117, 21629, 22140, 22652, 23164, 23675, 24187, 24699, 25210, 25722, 26234, 26745, 27257, 27769, 28280, 28792, 29304, 29815, 30327, 30839, 31350, 31862, 32374, 32885, 33397, 33909, 34420, 34932, 35444, 35955, 36467, 36979, 37490, 38002, 38514]
    攻击次数1 = 5
    CD = 30
    TP成长 = 0.10
    TP上限 = 5
    倍率 = 1
    是否有护石 = 1
    护石选项 = ['魔界', '圣痕']
    def 装备护石(self, x):
        if x == 0:
            self.倍率 *= 1.21
            self.CD *= 0.9
        elif x == 1:
            self.倍率 *= 1.29
            self.CD *= 0.9

    def 等效百分比(self, 武器类型):
        return (self.数据1[self.等级] * self.攻击次数1) * (1 + self.TP成长 * self.TP等级) * self.倍率


class 黑暗武士技能31(黑暗武士主动技能):
    名称 = '斩龙破'
    所在等级 = 70
    等级上限 = 40
    基础等级 = 18
    数据1 = [0, 1738, 1914, 2091, 2267, 2444, 2620, 2796, 2973, 3149, 3325, 3502, 3678, 3855, 4031, 4207, 4384, 4560, 4736, 4913, 5089, 5266, 5442, 5618, 5795, 5971, 6147, 6324, 6500, 6677, 6853, 7029, 7206, 7382, 7558, 7735, 7911, 8088, 8264, 8440, 8617, 8793, 8969, 9146, 9322, 9499, 9675, 9851, 10028, 10204, 10380, 10557, 10733, 10910, 11086, 11262, 11439, 11615, 11791, 11968, 12144, 12321, 12497, 12673, 12850, 13026, 13202, 13379, 13555, 13732, 13908]
    数据2 = [0, 1738, 1914, 2091, 2267, 2444, 2620, 2796, 2973, 3149, 3325, 3502, 3678, 3855, 4031, 4207, 4384, 4560, 4736, 4913, 5089, 5266, 5442, 5618, 5795, 5971, 6147, 6324, 6500, 6677, 6853, 7029, 7206, 7382, 7558, 7735, 7911, 8088, 8264, 8440, 8617, 8793, 8969, 9146, 9322, 9499, 9675, 9851, 10028, 10204, 10380, 10557, 10733, 10910, 11086, 11262, 11439, 11615, 11791, 11968, 12144, 12321, 12497, 12673, 12850, 13026, 13202, 13379, 13555, 13732, 13908]
    数据3 = [0, 15840, 17447, 19054, 20661, 22268, 23875, 25482, 27088, 28695, 30302, 31909, 33516, 35123, 36730, 38337, 39944, 41551, 43158, 44765, 46372, 47979, 49586, 51193, 52800, 54407, 56014, 57621, 59228, 60835, 62442, 64049, 65656, 67263, 68870, 70477, 72084, 73691, 75298, 76905, 78512, 80119, 81726, 83333, 84940, 86546, 88153, 89760, 91367, 92974, 94581, 96188, 97795, 99402, 101009, 102616, 104223, 105830, 107437, 109044, 110651, 112258, 113865, 115472, 117079, 118686, 120293, 121900, 123507, 125114, 126721]
    攻击次数1 = 1
    攻击次数2 = 1
    攻击次数3 = 1
    CD = 45
    TP成长 = 0.10
    TP上限 = 5
    是否有护石 = 1
    护石选项 = ['魔界', '圣痕']
    def 装备护石(self, x):
        if x == 0:
            self.攻击次数1 = 0
            self.攻击次数2 = 0
            self.数据3 = [int(i*0.274) for i in self.数据3]
            self.攻击次数3 = 6
            self.CD *= 0.9
        elif x == 1:
            self.攻击次数1 = 0
            self.攻击次数2 = 0
            self.数据3 = [int(i*0.29) for i in self.数据3]
            self.攻击次数3 = 6
            self.CD *= 0.9
    
    def 等效百分比(self, 武器类型):
        return (self.数据1[self.等级] * self.攻击次数1 + self.数据2[self.等级] * self.攻击次数2  + self.数据3[self.等级] * self.攻击次数3) * (1 + self.TP成长 * self.TP等级) * self.倍率

class 黑暗武士技能32(黑暗武士主动技能):
    名称 = '邪影升龙斩'
    武器惩罚类型 = '魔法固伤'
    所在等级 = 80
    等级上限 = 40
    基础等级 = 13
    数据1 = [0, 43584, 48006, 52427, 56849, 61271, 65692, 70114, 74536, 78957, 83379, 87801, 92222, 96644, 101065, 105487, 109909, 114330, 118752, 123174, 127595, 132017, 136439, 140860, 145282, 149703, 154125, 158547, 162968, 167390, 171812, 176233, 180655, 185077, 189498, 193920, 198341, 202763, 207185, 211606, 216028, 220450, 224871, 229293, 233715, 238136, 242558, 246979, 251401, 255823, 260244, 264666, 269088, 273509, 277931, 282353, 286774, 291196, 295617, 300039, 304461, 308882, 313304, 317726, 322147, 326569, 330991, 335412, 339834, 344255, 348677]
    CD = 50
    倍率 = 1
    是否有护石 = 1
    护石选项 = ['圣痕']
    def 装备护石(self, x):
        if x == 0:
            self.倍率 = 1.32

    def 等效百分比(self, 武器类型):
        return self.数据1[self.等级] * self.倍率

class 黑暗武士技能33(黑暗武士主动技能):
    名称 = '超时空碎裂'
    所在等级 = 85
    等级上限 = 40
    基础等级 = 5
    数据1 = [0, 2336, 2877, 3421, 3962, 4503, 5045, 5587, 6128, 6670, 7211, 7754, 8296, 8837, 9378, 9921, 10462, 11003, 11545, 12086, 12629, 13171, 13712, 14253, 14796, 15337, 15878, 16420, 16963, 17504, 18046, 18587, 19129, 19671, 20212, 20753, 21297, 21838, 22379, 22921, 23463, 24004, 24546, 25087, 25631, 26172, 26713, 27254, 27797, 28338, 28879, 29421, 29962, 30506, 31047, 31588, 32130, 32672, 33213, 33755, 34296, 34839, 35381, 35922, 36463, 37006, 37547, 38088, 38630, 39173, 39714]
    数据2 = [0, 44386, 54677, 64970, 75263, 85555, 95847, 106139, 116430, 126723, 137016, 147310, 157601, 167893, 178187, 188478, 198771, 209064, 219353, 229647, 239940, 250231, 260524, 270817, 281110, 291402, 301694, 311988, 322279, 332571, 342863, 353154, 363448, 373740, 384034, 394325, 404618, 414911, 425203, 435494, 445787, 456078, 466372, 476664, 486955, 497249, 507541, 517835, 528126, 538419, 548710, 559002, 569295, 579588, 589879, 600172, 610465, 620758, 631050, 641342, 651636, 661925, 672219, 682511, 692802, 703096, 713388, 723680, 733973, 744266, 754559]
    攻击次数1 = 19
    攻击次数2 = 1
    CD = 180
    #基础 = 1793
    #成长 = 542
    #基础2 = 34095
    #成长2 = 10292
    def 等效百分比(self, 武器类型):
        return (self.数据1[self.等级] * self.攻击次数1 + self.数据2[self.等级] * self.攻击次数2) * self.倍率


class 黑暗武士技能34(被动技能):
    名称 = '暗·短剑精通'
    所在等级 = 15
    等级上限 = 40
    基础等级 = 30
    关联技能 = ['所有']
    数据1 = [0, 14, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180, 195, 210, 225, 240, 255, 270, 285, 300, 315, 330, 345, 360, 375, 390, 405, 420, 435, 450, 465, 480, 495, 510, 525, 540, 555, 570, 585, 600, 615, 630, 645, 660, 675, 690, 705, 720, 735, 750, 765, 780, 795, 810, 825, 840, 855, 870, 885, 900, 915, 930, 945, 960, 975, 990, 1005, 1020, 1035, 1050]
    数据2 = [0, 12, 26, 39, 51, 64, 77, 90, 103, 116, 129, 141, 154, 167, 180, 193, 206, 219, 231, 244, 257, 270, 283, 296, 309, 321, 334, 347, 360, 373, 386, 399, 411, 424, 437, 450, 463, 476, 489, 501, 514, 527, 540, 553, 566, 579, 591, 604, 617, 630, 643, 656, 669, 681, 694, 707, 720, 733, 746, 759, 771, 784, 797, 810, 823, 836, 849, 861, 874, 887, 900]
    #物理攻击
    def 加成倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '短剑':
            return 1.0
        else:
            return round(1 + self.数据1[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.015, 5)

    #魔法攻击
    def 加成倍率2(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '短剑':
            return 1.0
        else:
            return round(1 + self.数据2[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.0129, 5)

    #物理攻击力面板
    def 物理攻击力倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '短剑':
            return 1.0
        else:
            return round(1 + self.数据1[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.015, 5)

    #魔法攻击力面板
    def 魔法攻击力倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '短剑':
            return 1.0
        else:
            return round(1 + self.数据2[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.0129, 5)

class 黑暗武士技能35(被动技能):
    名称 = '暗·太刀精通'
    所在等级 = 15
    等级上限 = 40
    基础等级 = 30
    关联技能 = ['所有']
    数据1 = [0, 13, 26, 39, 52, 65, 78, 91, 104, 117, 130, 143, 156, 169, 182, 195, 208, 221, 234, 247, 260, 273, 286, 299, 312, 325, 338, 351, 364, 377, 390, 403, 416, 429, 442, 455, 468, 481, 494, 507, 520, 533, 546, 559, 572, 585, 598, 611, 624, 637, 650, 663, 676, 689, 702, 715, 728, 741, 754, 767, 780, 793, 806, 819, 832, 845, 858, 871, 884, 897, 910]
    数据2 = [0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 168, 180, 192, 204, 216, 228, 240, 252, 264, 276, 288, 300, 312, 324, 336, 348, 360, 372, 384, 396, 408, 420, 432, 444, 456, 468, 480, 492, 504, 516, 528, 540, 552, 564, 576, 588, 600, 612, 624, 636, 648, 660, 672, 684, 696, 708, 720, 732, 744, 756, 768, 780, 792, 804, 816, 828, 840]

    # 物理攻击
    def 加成倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '太刀':
            return 1.0
        else:
            return round(1 + self.数据1[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.013, 5)

    # 魔法攻击
    def 加成倍率2(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '太刀':
            return 1.0
        else:
            return round(1 + self.数据2[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.012, 5)

    # 物理攻击力面板
    def 物理攻击力倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '太刀':
            return 1.0
        else:
            return round(1 + self.数据1[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.013, 5)

    # 魔法攻击力面板
    def 魔法攻击力倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '太刀':
            return 1.0
        else:
            return round(1 + self.数据2[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.012, 5)

class 黑暗武士技能36(被动技能):
    名称 = '暗·巨剑精通'
    所在等级 = 15
    等级上限 = 40
    基础等级 = 30
    关联技能 = ['所有']
    数据1 = [0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 168, 180, 192, 204, 216, 228, 240, 252, 264, 276, 288, 300, 312, 324, 336, 348, 360, 372, 384, 396, 408, 420, 432, 444, 456, 468, 480, 492, 504, 516, 528, 540, 552, 564, 576, 588, 600]
    数据2 = [0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 168, 180, 192, 204, 216, 228, 240, 252, 264, 276, 288, 300, 312, 324, 336, 348, 360, 372, 384, 396, 408, 420, 432, 444, 456, 468, 480, 492, 504, 516, 528, 540, 552, 564, 576, 588, 600]
    # 物理攻击
    def 加成倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '巨剑':
            return 1.0
        else:
            return round(1 + self.数据1[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.012, 5)

    # 魔法攻击
    def 加成倍率2(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '巨剑':
            return 1.0
        else:
            return round(1 + self.数据2[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.012, 5)

    # 物理攻击力面板
    def 物理攻击力倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '巨剑':
            return 1.0
        else:
            return round(1 + self.数据1[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.012, 5)

    # 魔法攻击力面板
    def 魔法攻击力倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '巨剑':
            return 1.0
        else:
            return round(1 + self.数据2[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.012, 5)

class 黑暗武士技能37(被动技能):
    名称 = '暗·钝器精通'
    所在等级 = 15
    等级上限 = 40
    基础等级 = 30
    关联技能 = ['所有']
    数据1 = [0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 168, 180, 192, 204, 216, 228, 240, 252, 264, 276, 288, 300, 312, 324, 336, 348, 360, 372, 384, 396, 408, 420, 432, 444, 456, 468, 480, 492, 504, 516, 528, 540, 552, 564, 576, 588, 600, 612, 624, 636, 648, 660, 672, 684, 696, 708, 720, 732, 744, 756, 768, 780, 792, 804, 816, 828, 840]
    数据2 = [0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 168, 180, 192, 204, 216, 228, 240, 252, 264, 276, 288, 300, 312, 324, 336, 348, 360, 372, 384, 396, 408, 420, 432, 444, 456, 468, 480, 492, 504, 516, 528, 540, 552, 564, 576, 588, 600, 612, 624, 636, 648, 660, 672, 684, 696, 708, 720, 732, 744, 756, 768, 780, 792, 804, 816, 828, 840]

    # 物理攻击
    def 加成倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '钝器':
            return 1.0
        else:
            return round(1 + self.数据1[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.012, 5)

    # 魔法攻击
    def 加成倍率2(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '钝器':
            return 1.0
        else:
            return round(1 + self.数据2[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.012, 5)

    # 物理攻击力面板
    def 物理攻击力倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '钝器':
            return 1.0
        else:
            return round(1 + self.数据1[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.012, 5)

    # 魔法攻击力面板
    def 魔法攻击力倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '钝器':
            return 1.0
        else:
            return round(1 + self.数据2[self.等级] / 1000, 5)
            #return round(1.00 + self.等级 * 0.012, 5)

class 黑暗武士技能38(被动技能):
    名称 = '暗·光剑精通'
    所在等级 = 15
    等级上限 = 40
    基础等级 = 30
    关联技能 = ['所有']
    数据1 = [0, 26, 40, 53, 66, 79, 92, 106, 119, 132, 145, 158, 172, 185, 198, 211, 224, 238, 251, 264, 277, 290, 304, 317, 330, 343, 356, 370, 383, 396, 409, 422, 436, 449, 462, 475, 488, 502, 515, 528, 541, 554, 568, 581, 594, 607, 620, 634, 647, 660, 660]
    数据2 = [0, 26, 40, 53, 66, 79, 92, 106, 119, 132, 145, 158, 172, 185, 198, 211, 224, 238, 251, 264, 277, 290, 304, 317, 330, 343, 356, 370, 383, 396, 409, 422, 436, 449, 462, 475, 488, 502, 515, 528, 541, 554, 568, 581, 594, 607, 620, 634, 647, 660, 660]
    # 物理攻击
    def 加成倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '光剑':
            return 1.0
        else:
            return round(1 + self.数据1[self.等级] / 1000, 5)
            #return round(1.02 + self.等级 * 0.013, 5)

    # 魔法攻击
    def 加成倍率2(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '光剑':
            return 1.0
        else:
            return round(1 + self.数据2[self.等级] / 1000, 5)
            #return round(1.02 + self.等级 * 0.013, 5)

    # 物理攻击力面板
    def 物理攻击力倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '光剑':
            return 1.0
        else:
            return round(1 + self.数据1[self.等级] / 1000, 5)
            #return round(1.02 + self.等级 * 0.013, 5)

    # 魔法攻击力面板
    def 魔法攻击力倍率(self, 武器类型):
        if self.等级 == 0 or 武器类型 != '光剑':
            return 1.0
        else:
            return round(1 + self.数据2[self.等级] / 1000, 5)
            #return round(1.02 + self.等级 * 0.013, 5)

class 黑暗武士技能39(被动技能):
    名称 = '时间停滞'
    所在等级 = 48
    等级上限 = 40
    基础等级 = 20
    关联技能 = ['所有']
    def 加成倍率(self, 武器类型):
        if self.等级 <= 15:
            return round(1.045 + 0.01 * self.等级, 5)
        else:
            return round(0.97 + 0.015 * self.等级, 5)

class 黑暗武士技能40(被动技能):
    名称 = '次元融合'
    所在等级 = 75
    等级上限 = 40
    基础等级 = 11
    关联技能 = ['无']
    自定义描述 = 1
    def 技能描述(self, 武器类型):
        return '力量/智力+' + str(int(self.力智倍率() * 100 - 100)) + '%'

    def 力智倍率(self):
        return round(1 + 0.02 * self.等级, 5)
        #每级2%力智

class 黑暗武士技能41(被动技能):
    名称 = '自我觉醒'
    所在等级 = 75
    等级上限 = 1
    基础等级 = 1
    关联技能 = ['所有']
    def 加成倍率(self, 武器类型):
        if self.等级 == 0:
            return 1.0
        return round(1.01 + 0.1 * self.等级, 5)

    def 物理攻击力倍率(self, 武器类型):
        if self.等级 == 0:
            return 1.0
        else:
            return round(1.01 + self.等级 * 0.1, 5)

    # 魔法攻击力面板
    def 魔法攻击力倍率(self, 武器类型):
        if self.等级 == 0:
            return 1.0
        else:
            return round(1.01 + self.等级 * 0.1, 5)

class 黑暗武士技能42(被动技能):
    名称 = '卓越之力'
    所在等级 = 95
    等级上限 = 40
    基础等级 = 4
    关联技能 = ['所有']

    def 加成倍率(self, 武器类型):
        if self.等级 == 0:
            return 1.0
        else:
            return round(1.18 + 0.02 * self.等级, 5)

class 黑暗武士技能43(被动技能):
    名称 = '超卓之心'
    所在等级 = 95
    等级上限 = 11
    基础等级 = 1
    关联技能 = ['所有']

    def 加成倍率(self, 武器类型):
        if self.等级 == 0:
            return 1.0
        else:
            return round(1.045 + 0.005 * self.等级, 5)

class 黑暗武士技能44(被动技能):
    名称 = '觉醒之抉择'
    所在等级 = 100
    等级上限 = 40
    基础等级 = 2
    关联技能 = ['超时空碎裂']

    def 加成倍率(self, 武器类型):
        if self.等级 == 0:
            return 1.0
        else:
            return round(1.10 + 0.05 * self.等级, 5)

class 黑暗武士技能45(被动技能):
    名称 = '基础精通'
    倍率 = 1.0
    所在等级 = 1
    等级上限 = 200
    基础等级 = 100
    关联技能 = ['挑击']
    数据1 = [0, 1000, 1058, 1115, 1173, 1230, 1288, 1345, 1403, 1461, 1518, 1576, 1633, 1691, 1748, 1806, 1895, 1984, 2073, 2162, 2251, 2339, 2428, 2517, 2606, 2695, 2784, 2873, 2962, 3051, 3140, 3228, 3317, 3406, 3495, 3584, 3673, 3762, 3851, 3940, 4029, 4118, 4206, 4295, 4384, 4473, 4562, 4651, 4740, 4829, 4918, 5007, 5095, 5184, 5273, 5362, 5451, 5540, 5629, 5718, 5807, 5896, 5985, 6073, 6162, 6251, 6340, 6429, 6518, 6607, 6696, 6785, 6874, 6963, 7051, 7140, 7229, 7318, 7407, 7496, 7585, 7674, 7763, 7852, 7940, 8029, 8118, 8207, 8296, 8385, 8474, 8563, 8652, 8741, 8830, 8918, 9007, 9096, 9185, 9274, 9363, 9452, 9541, 9630, 9719, 9808, 9897, 9986, 10075, 10164, 10253, 10342, 10431, 10520, 10609, 10698, 10787, 10876, 10965, 11054, 11143, 11232, 11321, 11410, 11499, 11588, 11677, 11766, 11855, 11944, 12033, 12122, 12211, 12300, 12389, 12478, 12567, 12656, 12745, 12834, 12923, 13012, 13101, 13190, 13279, 13368, 13457, 13546, 13635, 13724, 13813, 13902, 13991, 14080, 14169, 14258, 14347, 14436, 14525, 14614, 14703, 14792, 14881, 14970, 15059, 15148, 15237, 15326, 15415, 15504, 15593, 15682, 15771, 15860, 15949, 16038, 16127, 16216, 16305, 16394, 16483, 16572, 16661, 16750, 16839, 16928, 17017, 17106, 17195, 17284, 17373, 17462, 17551, 17640, 17729, 17818, 17907, 17996, 18085, 18174, 18263]
    def 加成倍率(self, 武器类型):
        if self.等级 == 0:
            return 1.0
        else:
            return round( self.数据1[self.等级] / 1000 , 5)

黑暗武士技能列表 = []
i = 0
while i >= 0:
    try:
        exec('黑暗武士技能列表.append(黑暗武士技能'+str(i)+'())')
        i += 1
    except:
        i = -1

黑暗武士技能序号 = dict()
for i in range(len(黑暗武士技能列表)):
    黑暗武士技能序号[黑暗武士技能列表[i].名称] = i


黑暗武士二觉序号 = 0
黑暗武士三觉序号 = 0
for i in 黑暗武士技能列表:
    if i.所在等级 == 85:
        黑暗武士二觉序号 = 黑暗武士技能序号[i.名称]
    if i.所在等级 == 100:
        黑暗武士三觉序号 = 黑暗武士技能序号[i.名称]

黑暗武士护石选项 = ['无']
for i in 黑暗武士技能列表:
    if i.是否有伤害 == 1 and i.是否有护石 == 1:
        黑暗武士护石选项.append(i.名称)

黑暗武士符文选项 = ['无']
for i in 黑暗武士技能列表:
    if i.所在等级 >= 20 and i.所在等级 <= 80 and i.是否有伤害 == 1:
        黑暗武士符文选项.append(i.名称)

class 黑暗武士角色属性(角色属性):

    实际名称 = '黑暗武士'
    角色 = '黑暗武士'
    职业 = '黑暗武士'

    武器选项 = ['光剑','太刀','巨剑','短剑','钝器']
    
    类型选择 = ['物理百分比','魔法百分比']
    
    #默认
    类型 = '物理百分比'
    防具类型 = '轻甲'
    防具精通属性 = ['力量','智力']

    主BUFF = 1.54
   
    远古记忆 = 0
    
    #计算CD
    排列技能 = ['无', '无', '无', '无', '无'] * 6

    def __init__(self):
        基础属性输入(self)
        self.技能栏= deepcopy(黑暗武士技能列表)
        self.技能序号= deepcopy(黑暗武士技能序号)

    def 被动倍率计算(self):
        
        self.排列CD计算()

        if self.远古记忆 > 0:
            self.进图智力 += self.远古记忆 * 15

        for i in ['暗·太刀精通','暗·短剑精通','暗·巨剑精通','暗·光剑精通','暗·钝器精通']:
            if self.武器类型 not in i:
                self.技能栏[self.技能序号[i]].关联技能 = ['无']

        for i in self.技能栏:
            if i.关联技能 != ['无']:
                if i.关联技能 == ['所有']:
                    for j in self.技能栏:
                        if j.是否有伤害 == 1:
                            # 分物理魔法 调用武器精通的加成倍率
                            if i.名称 in ['暗·太刀精通','暗·短剑精通','暗·巨剑精通','暗·光剑精通','暗·钝器精通']:
                                #if j.类型 == '物理':
                                if self.类型 == '物理百分比':
                                    j.被动倍率 *= i.加成倍率(self.武器类型)
                                else:
                                    j.被动倍率 *= i.加成倍率2(self.武器类型)
                            else:
                                j.被动倍率 *= i.加成倍率(self.武器类型)
                else :
                    for k in i.关联技能:
                        self.技能栏[self.技能序号[k]].被动倍率 *= i.加成倍率(self.武器类型)

    def 伤害指数计算(self):
        
        防御 = max(self.防御输入 - self.固定减防, 0) * (1 - self.百分比减防)
        基准倍率 = 1.5 * self.主BUFF * (1 - 防御 / (防御+ 20000))

        #避免出现浮点数取整BUG
        self.伤害增加 += 0.00000001
        
        self.属性倍率计算()

        if self.计算自适应 == 1:
            self.自适应计算()

        # self.希洛克武器提升()

        面板1 = int((self.面板力量() / 250 + 1) * (self.物理攻击力 + self.进图物理攻击力) * (1 + self.百分比三攻))
        面板2 = int((self.面板智力() / 250 + 1) * (self.魔法攻击力 + self.进图魔法攻击力) * (1 + self.百分比三攻))

        增伤倍率 = 1 + int(self.伤害增加 * 100) / 100
        增伤倍率 *= 1 + self.暴击伤害
        增伤倍率 *= 1 + self.最终伤害
        增伤倍率 *= self.技能攻击力
        增伤倍率 *= 1 + self.持续伤害 * self.持续伤害计算比例
        增伤倍率 *= 1 + self.附加伤害 + self.属性附加 * self.属性倍率
        self.伤害指数1 = 面板1 * self.属性倍率 * 增伤倍率 * 基准倍率 / 100 * self.队友增幅系数* (1 + self.希洛克BUFF * 0.15)
        self.伤害指数2 = 面板2 * self.属性倍率 * 增伤倍率 * 基准倍率 / 100 * self.队友增幅系数* (1 + self.希洛克BUFF * 0.15)

    def 排列CD计算(self):
        # super().CD倍率计算()
        for i in self.排列技能:
            count = 0
            总CD = 0
            恢复速度 = 1
            # 大恍惚CD加速只加速15级以上的，15级以下无效，所以DK在拿15级以下的技能垫技能的时候，会造成整个下排CD加速无效的BUG
            # 先检查是否存在等级<15,造成冷却恢复排列失效的
            if self.装备检查('拥抱晨曦之温暖') or self.装备检查('融化黑暗之温暖'):
                for j in i:
                    if j!='无' and self.技能栏[self.技能序号[j]].所在等级<15:
                        恢复速度 = 0
            for j in i:
                if j != '无':
                    count += 1
                    总CD += self.技能栏[self.技能序号[j]].等效CD(self.武器类型,self.类型,恢复速度)
            if count != 0:
                计算CD = 总CD / count * 1.2
                for j in i:
                    if j != '无':
                        self.技能栏[self.技能序号[j]].计算CD = 计算CD

    def 技能单次伤害计算(self, y):
        #y切装标记
        技能单次伤害 = []
        for i in self.技能栏:
            if i.是否有伤害 == 1 and self.技能切装[self.技能序号[i.名称]] != y:
                # 分物理魔法 乘伤害指数
                if i.类型 == '物理':
                    技能单次伤害.append(i.等效百分比(self.武器类型) * self.伤害指数1 * i.被动倍率)
                else:
                    技能单次伤害.append(i.等效百分比(self.武器类型) * self.伤害指数2 * i.被动倍率)
            else:
                技能单次伤害.append(0)
        return 技能单次伤害

    def 站街力量(self):
        return int(max(self.力量, self.智力) * self.技能栏[self.技能序号['次元融合']].力智倍率())

    def 站街智力(self):
        return self.站街力量()

    def 面板力量(self,取整=1):
        if self.系统奶 == False:
            if 取整==1:
                power = int(int((self.力量 + self.进图力量)) * (1 + self.百分比力智) * self.技能栏[self.技能序号['次元融合']].力智倍率())
                intelligence = int(int((self.智力 + self.进图智力)) * (1 + self.百分比力智) * self.技能栏[self.技能序号['次元融合']].力智倍率())
                return int(max(power,intelligence))
            else:
                power = (self.力量 + self.进图力量) * (1 + self.百分比力智) * self.技能栏[self.技能序号['次元融合']].力智倍率()
                intelligence = (self.智力 + self.进图智力) * (1 + self.百分比力智) * self.技能栏[self.技能序号['次元融合']].力智倍率()
                return max(power,intelligence)
        else:
            if 取整==1:
                power = int(int((self.力量 + int((self.力量 - self.基础力量) * 1.35 + 7664) +self.进图力量)) * (1 + self.百分比力智) * self.技能栏[self.技能序号['次元融合']].力智倍率())
                intelligence = int(int((self.智力 + int((self.智力 - self.基础智力) * 1.35 + 7664) +self.进图智力)) * (1 + self.百分比力智) * self.技能栏[self.技能序号['次元融合']].力智倍率())
                return int(max(power,intelligence))
            else:
                power = (self.力量 + int((self.力量 - self.基础力量) * 1.35 + 7664) +self.进图力量) * (1 + self.百分比力智) * self.技能栏[self.技能序号['次元融合']].力智倍率()
                intelligence = (self.智力 + int((self.智力 - self.基础智力) * 1.35 + 7664) +self.进图智力) * (1 + self.百分比力智) * self.技能栏[self.技能序号['次元融合']].力智倍率()
                return max(power,intelligence)

           
    def 面板智力(self,取整=1):
        return self.面板力量(取整)

class 黑暗武士(角色窗口):

    def 窗口属性输入(self):
        self.初始属性 = 黑暗武士角色属性()
        self.角色属性A = 黑暗武士角色属性()
        self.角色属性B = 黑暗武士角色属性()
        self.一觉序号 = 黑暗武士二觉序号
        self.二觉序号 = 黑暗武士二觉序号
        self.三觉序号 = 黑暗武士三觉序号
        self.护石选项 = deepcopy(黑暗武士护石选项)
        self.符文选项 = deepcopy(黑暗武士符文选项)

    def 界面(self):
        super().界面()
        
        # for i in ([self.守门人属强] + self.希洛克套装按钮 + self.希洛克单件按钮 + self.希洛克装备图标 + self.希洛克武器词条):
        #     i.move(i.x() - 85, i.y() + 380)

        for i in [self.觉醒选择, self.一觉图片, self.二觉图片, self.一觉遮罩, self.二觉遮罩]:
            i.move(-1000, -1000)

        for i in self.角色属性A.技能栏:
            序号 = self.角色属性A.技能序号[i.名称]
            if i.所在等级 == 50:
                self.等级调整[序号].clear()
                for j in range(- i.基础等级, i.等级上限 - i.基础等级 + 1):
                    self.等级调整[序号].addItem(str(j))
        
        初始x = 310; 初始y = 640
        self.技能排列=QLabel(self.main_frame2)
        self.技能排列.setPixmap(QPixmap('./ResourceFiles/'+self.角色属性A.实际名称 + "/技能/skill.png"))
        self.技能排列.resize(242, 293)
        self.技能排列.move(初始x, 初始y)

        技能名称 = ['无']
        for i in self.初始属性.技能栏:
            if i.是否主动 == 1:
                技能名称.append(i.名称)

        self.技能排列 = []
        self.排列图片 = []
        for i in range(6):
            temp = []
            temp2 = []
            for j in range(6):
                temp.append(MyQComboBox(self.main_frame2))
                temp[j].resize(100, 22)
                temp[j].addItems(技能名称)
                temp[j].currentIndexChanged.connect(lambda state, x = i, y = j:self.排列图片更改(x, y))
                if i == 0:
                    temp[j].move(310 + 110 * j, 440 + 28 * i)
                else:
                    temp[j].move(310 + 110 * j, 450 + 28 * i)
                temp2.append(QLabel(self.main_frame2))
                temp2[j].resize(26, 26)
                temp2[j].setAlignment(Qt.AlignCenter) 
                if i == 0:
                    temp2[j].move(初始x + 10 + 39 * j, 初始y + 24 + 44 * i)
                else:
                    temp2[j].move(初始x + 10 + 39 * j, 初始y + 39 + 44 * i)
            self.技能排列.append(temp)
            self.排列图片.append(temp2)

        self.清空排列按钮 = QPushButton('清空排列', self.main_frame2)
        self.清空排列按钮.clicked.connect(lambda state: self.清空排列())
        self.清空排列按钮.move(850, 400)
        self.清空排列按钮.resize(100, 20)
        self.清空排列按钮.setStyleSheet(按钮样式)

        self.护甲精通选择=MyQComboBox(self.main_frame2)
        self.护甲精通选择.addItem('轻甲')
        self.护甲精通选择.addItem('布甲')
        self.护甲精通选择.addItem('重甲')
        self.护甲精通选择.addItem('板甲')
        self.护甲精通选择.resize(120,20)
        self.护甲精通选择.move(720,400)

    def 清空排列(self):

        box = QMessageBox(QMessageBox.Warning, "提示", "是否清空排列？")
        box.setWindowIcon(self.icon)
        yes = box.addButton(self.tr("确定"), QMessageBox.YesRole)
        no = box.addButton(self.tr("取消"), QMessageBox.NoRole)
        box.exec_()
        if box.clickedButton() == yes:
            for i in self.技能排列:
                for j in i:
                    j.setCurrentIndex(0)
        
    def 排列图片更改(self, x, y):
        技能字典 = {}
        for i in self.技能排列:
            for j in i:
                if j.currentText() != '无':
                    技能字典[j.currentText()] = 技能字典.get(j.currentText(), 0) + 1

        if self.技能排列[x][y].currentText() != '无':
            self.排列图片[x][y].setPixmap(self.技能图片[self.角色属性A.技能序号[self.技能排列[x][y].currentText()]])
            if 技能字典[self.技能排列[x][y].currentText()] > 1:
                self.技能排列[x][y].setStyleSheet(下拉框样式_warn)
            else:
                self.技能排列[x][y].setStyleSheet(下拉框样式)
        else:
            self.排列图片[x][y].setPixmap(QPixmap('无'))
            self.技能排列[x][y].setStyleSheet(下拉框样式)
    
    def 输入属性(self, 属性, x = 0):
        super().输入属性(属性, x)

        排列倍率 = [2, 1, 1.3, 1.5, 1.8, 2]

        for i in range(6):
            for j in range(6):
                if self.技能排列[i][j].currentText() != '无':
                    属性.技能栏[属性.技能序号[self.技能排列[i][j].currentText()]].倍率 *= 排列倍率[i]

        排列技能 = []
        for j in range(6):
            temp = []
            for i in range(1, 6):
                temp.append(self.技能排列[i][j].currentText())
            排列技能.append(temp)
            
        属性.排列技能 = deepcopy(排列技能)

        for i in 属性.技能栏:
            if i.是否主动 == 1 and i.所在等级 >= 40 and i.名称 != '禁魂斩':
                if 属性.类型 == '物理百分比':
                    i.类型 = '物理'
                else:
                    i.类型 = '魔法'

        #防具类型 = '轻甲'

        属性.护甲精通 = self.护甲精通选择.currentIndex()
        if 属性.护甲精通 == 0:
            属性.防具类型 = '轻甲'
            属性.防具精通属性 = ['力量']
        elif 属性.护甲精通 == 1:
            属性.防具类型 = '布甲'
            属性.防具精通属性 = ['智力']
        elif 属性.护甲精通 == 2:
            属性.防具类型 = '重甲'
            属性.防具精通属性 = ['力量']
        elif 属性.护甲精通 == 3:
            属性.防具类型 = '板甲'
            属性.防具精通属性 = ['智力']

    def 载入配置(self, path = 'set'):
        super().载入配置(path)
        try:
            setfile = open('./ResourceFiles/'+self.角色属性A.实际名称 + '/' + path + '/skill5.ini', 'r', encoding='utf-8').readlines()
            num = 0
            for i in range(6):
                for j in range(6):
                    self.技能排列[i][j].setCurrentIndex(int(setfile[num].replace('\n', ''))); num += 1

            self.护甲精通选择.setCurrentIndex(int(setfile[num].replace('\n', ''))); num += 1
        except:
            pass

    def 保存配置(self, path = 'set'):
        super().保存配置(path)
        try:
            setfile = open('./ResourceFiles/'+self.角色属性A.实际名称 + '/' + path + '/skill5.ini', 'w', encoding='utf-8')
            for i in range(6):
                for j in range(6):
                    setfile.write(str(self.技能排列[i][j].currentIndex())+'\n')
            setfile.write(str(self.护甲精通选择.currentIndex())+'\n')
        except:
            pass


